package com.huaxin.hxmoduleworkorder.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huaxin.hxmoduleworkorder.dto.ResponseCode;
import com.huaxin.hxmoduleworkorder.dto.ResponseResult;
import com.huaxin.hxmoduleworkorder.dto.request.InspectionTemplateItemRelCreateReqDTO;
import com.huaxin.hxmoduleworkorder.mapper.InspectionTemplateItemRelMapper;
import com.huaxin.hxmoduleworkorder.mapping.InspectionTemplateItemRelMapping;
import com.huaxin.hxmoduleworkorder.models.InspectionTemplateItem;
import com.huaxin.hxmoduleworkorder.models.InspectionTemplateItemRel;
import com.huaxin.hxmoduleworkorder.service.InspectionTemplateItemRelService;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
@RequiredArgsConstructor
public class InspectionTemplateItemRelServiceImpl extends ServiceImpl<InspectionTemplateItemRelMapper, InspectionTemplateItemRel> implements InspectionTemplateItemRelService {
    private final ApplicationContext applicationContext;
    private final InspectionTemplateItemRelMapping mapping;

    @Override
    public ResponseResult<InspectionTemplateItemRel> create(InspectionTemplateItemRelCreateReqDTO in) {
        if (in == null) {
            return ResponseResult.parameterError(null, "参数不能为空");
        }
        if (StringUtils.isBlank(in.getTemplateItemId())) {
            return ResponseResult.parameterError(null, "模板项ID不能为空");
        }
        if (in.getSortOrder() == null) {
            return ResponseResult.parameterError(null, "排序序号不能为空");
        }
        if (!StringUtils.isBlank(in.getTemplateId())) {
            boolean exists = this.exists(new LambdaQueryWrapper<InspectionTemplateItemRel>().eq(InspectionTemplateItemRel::getTemplateId, in.getTemplateId())
                    .eq(InspectionTemplateItemRel::getTemplateItemId, in.getTemplateItemId()));
            if (exists) {
                return ResponseResult.failure(ResponseCode.CUSTOM_BUSINESS_ERROR, "该模板项已关联，请勿重复添加", null);
            }
        }
        if (!StringUtils.isBlank(in.getCabinetType())) {
            boolean exists = this.exists(new LambdaQueryWrapper<InspectionTemplateItemRel>().eq(InspectionTemplateItemRel::getCabinetType, in.getCabinetType())
                    .eq(InspectionTemplateItemRel::getTemplateItemId, in.getTemplateItemId()));
            if (exists) {
                return ResponseResult.failure(ResponseCode.CUSTOM_BUSINESS_ERROR, "该配电箱类型已关联，请勿重复添加", null);
            }
        }
        InspectionTemplateItemRel entity = mapping.toEntity(in);
        if (save(entity)) {
            InspectionTemplateItemRel created = this.getById(entity.getId());
            return ResponseResult.ok(created);
        } else {
            return ResponseResult.failure(ResponseCode.INTERNAL_SERVER_ERROR, "添加失败，请稍后再试！", null);
        }
    }

    @Override
    public ResponseResult<String> delete(String templateId, String templateItemId) {
        if (StringUtils.isBlank(templateId)) {
            return ResponseResult.parameterError(null, "模版id不能为空");
        }
        if (StringUtils.isBlank(templateItemId)) {
            return ResponseResult.parameterError(null, "模版项id不能为空");
        }

        int i = this.baseMapper.deleteByTemplateIdAndTemplateItemId(templateId, templateItemId);
        if (i > 0) {
            return ResponseResult.ok("删除成功！");
        } else {
            return ResponseResult.failure(ResponseCode.INTERNAL_SERVER_ERROR, "删除失败，请稍后重试", null);
        }
    }

    @Override
    public ResponseResult<List<InspectionTemplateItem>> listByTemplateId(String templateId, String customerType) {
        if (StringUtils.isBlank(templateId)) {
            return ResponseResult.parameterError(null, "模版ID不能为空");
        }
        List<InspectionTemplateItem> list = this.baseMapper.getInspectionTemplateItemRelByTemplateId(templateId, customerType);
        if (list == null || list.isEmpty()) {
            return ResponseResult.notFound(null, "该模版暂无检查项");
        }
        return ResponseResult.ok(list);
    }

    @Override
    public ResponseResult<String> deleteByTemplateId(String templateId) {
        if (StringUtils.isBlank(templateId)) {
            return ResponseResult.parameterError(null, "模版ID不能为空");
        }
        int i = this.baseMapper.deleteByTemplateId(templateId);
        if (i > 0) {
            return ResponseResult.ok("删除成功！");
        } else {
            return ResponseResult.failure(ResponseCode.INTERNAL_SERVER_ERROR, "删除失败，请稍后重试", null);
        }
    }

    @Override
    public ResponseResult<List<InspectionTemplateItem>> listByCabinetType(String cabinetType) {
        if (StringUtils.isBlank(cabinetType)) {
            return ResponseResult.parameterError(null, "配电箱类型不能为空");
        }
        List<InspectionTemplateItem> list = this.baseMapper.getInspectionTemplateItemRelByCabinetType(cabinetType);
        if (list == null || list.isEmpty()) {
            return ResponseResult.notFound(null, "该配电箱暂无检查项");
        }
        return ResponseResult.ok(list);
    }

    @Override
    public ResponseResult<String> deleteByCabinetType(String cabinetType, String templateItemId) {
        if (StringUtils.isBlank(cabinetType)) {
            return ResponseResult.parameterError(null, "配电箱类型不能为空");
        }
        int i = this.baseMapper.deleteByCabinetType(cabinetType, templateItemId);
        if (i > 0) {
            return ResponseResult.ok("删除成功！");
        } else {
            return ResponseResult.failure(ResponseCode.INTERNAL_SERVER_ERROR, "删除失败，请稍后重试", null);
        }
    }

    @Override
    public ResponseResult<String> deleteByRelId(String relId) {
        if (StringUtils.isBlank(relId)) {
            return ResponseResult.parameterError(null, "关联关系ID不能为空");
        }
        int i = this.baseMapper.deleteByRelId(relId);
        if (i > 0) {
            return ResponseResult.ok("删除成功！");
        } else {
            return ResponseResult.failure(ResponseCode.INTERNAL_SERVER_ERROR, "删除失败，请稍后重试", null);
        }
    }

    @Override
    public ResponseResult<Boolean> existsByCabinetType(String cabinetType) {
        return ResponseResult.ok(this.exists(new LambdaQueryWrapper<InspectionTemplateItemRel>().eq(InspectionTemplateItemRel::getCabinetType, cabinetType)));
    }
}
